from PIL import Image
import networkx as nx
import os
import tempfile
os.environ['MPLCONFIGDIR'] = tempfile.mkdtemp()
import matplotlib.pyplot as plt
from flask import get_flashed_messages, request, flash, render_template, redirect, url_for, session, make_response
from models.item import metadata, Item
from models.atributoTipo import metadata, AtributoTipo
from models.database import db_session
import sys
import pydot
#import bz2
from models.itemManager import ItemManager
from models.tipoItemManager import TipoItemManager
from models.proyectoManager import ProyectoManager
from models.faseManager import FaseManager
from models.usuarioManager import UsuarioManager
from models.tipoRelacionManager import TipoRelacionManager
from models.relacionManager import RelacionManager
from models.relacion import Relacion
from models.historialManager import HistorialManager
from models.historialItem import HistorialItem
from models.atributoItem import atributoItem, AtributoItem
from models.historialRelacion import HistorialRelacion
from models.historialRelacionManager import HistorialRelacionManager
from models.historialAtributo import HistorialAtributo
from models.historialAtributoManager import HistorialAtributoManager
from models.adjunto import Adjunto
import datetime
from solicitudCambioView import obtenerDescendientes, obtenerAscendientes
from models.usuarioManager import UsuarioManager
from models.adjuntoManager import AdjuntoManager
from models.votosComiteManager import VotosComiteManager
from models.solicitudCambioManager import SolicitudCambioManager
from models.lineaBaseManager import LineaBaseManager

import sys
from epm import app



solicitudMgr = SolicitudCambioManager()
lineaBaseMgr = LineaBaseManager()
historialMgr = HistorialManager()
historialRelacionMgr = HistorialRelacionManager()
historialAtributoMgr = HistorialAtributoManager()
usuarioMgr= UsuarioManager()
proyectoMgr= ProyectoManager()
faseMgr= FaseManager()
itemMgr = ItemManager()
tipoRelacionMgr = TipoRelacionManager()
tipoItemMgr = TipoItemManager()
relacionMgr = RelacionManager()
usuarioMgr= UsuarioManager()
adjuntoMgr = AdjuntoManager()
votosMgr = VotosComiteManager()

"""
Clase que contiene los metodos relacionados con la gestion de items del sistema
"""

def abmItem():
    """ Metodo encargado de la gestion de items de un proyecto """
    filtro=""
    if request.method == "POST":
        idfase = request.form["idfase"]
        filtro = request.form["filtro"]
        fase = faseMgr.getFase(idfase)
        return paginarItem(idfase, fase, 1, filtro)
    if request.method == "GET":
        if session['idfase']:
            if request.args.getlist("filtro"):
                filtro = request.args.getlist("filtro")[0]
            pagina = 1
            if request.args.getlist("pagina"):
                pagina = request.args.getlist("pagina")[0]
            idfase = session['idfase']
            fase = faseMgr.getFase(idfase)
            return paginarItem(idfase, fase,pagina , filtro)
        else:
            if session['idproyecto']:
                flash(u"Seleccionar una fase del proyecto antes de realizar la operaci\u00f3n", "error")
            else:
                flash(u"Seleccionar un proyecto antes de realizar la operaci\u00f3n", "error")
            return redirect(url_for("configurarFase", action= "abmItem"))

def crearItem():
    """ Metodo encargado de guardar un item """
    
    if request.method == "POST":
        nombre = request.form["nombre"]
        costo = request.form["costo"]
        idfase = request.form["idfase"]
        complejidad = request.form["complejidad"]
        fechaini = request.form["fechaini"]
        fechafin = request.form["fechafin"]
        duracion = request.form["duracion"]
        version = request.form["version"] 
        codigotipoitem = request.form["codigotipoitem"]
        numeroitem = codigotipoitem + "-" + request.form["numeroitem"]
        idtipoitem = request.form["idtipoitem"]
        idcreador = request.form["creador"] 
        fase = faseMgr.getFase(idfase)
        creador = usuarioMgr.getUsuarioPorUser(idcreador)
        tipoItem = tipoItemMgr.getTipoItem(idtipoitem)
        get_flashed_messages(with_categories= True)
        item = Item(nombre=nombre, costo=costo, complejidad=complejidad, fechaInicio=fechaini, 
             fechaFin=fechafin, duracion=duracion, version=version, numeroItem=numeroitem, creador=creador,
             fechaUltimaMod= datetime.date.today(), usuarioUltimaMod=creador)
        item.idfase = fase.idfase
        item.idtipoitem = tipoItem.idtipoitem
        item.idestadoitem= 1
        itemMgr.guardarItem(item)
        fase.cant_items= fase.cant_items +1
        faseMgr.guardarFase(fase)
        if fase.numero != 1:
            session["_flashes"]=[]
            return redirect(url_for("modificarRelacion", filtro="", nroFase=fase.numero, iditem=item.iditem))
        return redirect(url_for("abmItem", idfase=idfase, filtro = request.form["filtro"]))
    else:
        idfase = request.args.getlist("idfase")[0]
        tipos = tipoItemMgr.getTipoItemFase(idfase)
        creador=session["username"]
        usuarioUltimaMod= creador
        if tipos:
            return render_template("crearItem.html",tipos=tipos, creador=creador
                               , usuarioUltimaMod= usuarioUltimaMod, idfase=idfase, 
                               filtro = request.args.getlist("filtro")[0])
        else: 
            flash("No exite ningun tipo de item en la fase, debe agregar al menos uno")
            return redirect(url_for("abmItem", idfase=idfase, filtro = request.args.getlist("filtro")[0]))

def adjuntar():
     """ Metodo encargado de adjuntar archivos a un item"""
     if request.method == "POST":
         idfase = session["idfase"]
         if request.form['boton_item']=='Asignar':
            file = request.files['file']
            iditem = request.form['iditem']
            #print "entro en asignar" 
            if file and allowed_file(file.filename):
                carga_archivo(iditem,file)
                #print "paso cargar"
                flash("Archivo asignado con exito")
            else:
                flash("Extension no valida para el archivo")
         return redirect(url_for('abmItem', idfase=idfase, filtro = ""))
     else:
         idfase = session["idfase"]
         iditem = request.args.getlist("iditem")[0]
         return render_template("adjuntar.html", idfase=idfase, iditem = iditem, filtro = "")
        

def modificarItem():
    """ Metodo encargado de modificar un item """
    
    if request.method == "GET":
        iditem = request.args.getlist("iditem")[0]
        item = itemMgr.getItem(iditem)
        tipoItem = item.tipoItem
        idfase = request.args.getlist("idfase")[0]
        #si el item esta en revision
        if item.idestadoitem==3:
            flash("El item no puede ser modificado porque esta afectado por una solicitud de cambio.")
            return redirect(url_for("abmItem"))  
        
        return render_template("modificarItem.html", tipoItem=tipoItem,idfase=idfase, item = item, filtro = request.args.getlist("filtro")[0] )
    if request.method == "POST":
        iditem = request.form["iditem"]
        item = itemMgr.getItem(iditem)
        if item.idestadoitem == 4:
            flash("El item ya se encuentra en una linea base, favor realizar antes una solicitud de cambio", "error")
            return redirect(url_for("abmItem", idfase=item.fase.idfase, filtro = request.form["filtro"]))
        
        
        ascendientes=[]
        obtenerAscendientes(ascendientes, item)
        for ascendiente in ascendientes:
            if ascendiente.solicitudes:
                solicitud=ascendiente.solicitudes[0]
                #si la solicitud esta en estado pendiente
                if solicitud.idestadosc==3:
                    solicitud.votos_a_favor=0
                    solicitud.votos_en_contra=0
                    votos= solicitud.votos
                    solicitudMgr.guardarSolicitudCambio(solicitud)
                    # si se modifico un item afectado por SC eliminar los votos
                    for voto in votos:
                        votosMgr.eliminarVoto(voto.idvoto)  
        session["_flashes"]=[]      
        crearHistorial(item)
        item.idestadoitem = 1
        item.nombre = request.form["nombre"]
        item.costo = request.form["costo"]
        idfase = request.form["idfase"]
        item.complejidad = request.form["complejidad"]
        item.fechainicio = request.form["fechaini"]
        item.fechafin = request.form["fechafin"]
        item.duracion = request.form["duracion"]
        item.version = int(request.form["version"]) + 1
        item.numeroitem = request.form["numeroitem"]
        item.idtipoitem = request.form["idtipoitem"]  
        item.fechaultimamod = datetime.date.today() 
        usuario=session["username"]
        usuarioUltimaMod = usuarioMgr.getUsuarioPorUser(usuario)
        item.usuarioUltimaMod= usuarioUltimaMod
        itemMgr.guardarItem(item)
        mensajes = get_flashed_messages(with_categories= True)
        categoria, mensaje = mensajes[0]
        if categoria == "error":
            flash(mensaje, categoria)
        else:
            flash("Modificado exitosamente");
        return redirect(url_for("abmItem", idfase=idfase, filtro = request.form["filtro"]))

def eliminarItem():
    """ Metodo encargado de eliminar un item """
    
    if request.method == "POST":
        iditem = request.form["iditem"]
        item=itemMgr.getItem(iditem)
        crearHistorial(item)
        item.idestadoitem=5
        item.version = int(item.version) + 1
        item.fechaultimamod = datetime.date.today() 
        usuario=session["username"]
        usuarioUltimaMod = usuarioMgr.getUsuarioPorUser(usuario)
        item.usuarioUltimaMod= usuarioUltimaMod
        itemMgr.guardarItem(item)
        idfase = request.form["idfase"]
        fase=faseMgr.getFase(idfase)
        fase.cant_items= fase.cant_items-1
        faseMgr.guardarFase(fase)
        session["_flashes"]=[]
        flash("Item eliminado exitosamente")
        return redirect(url_for("abmItem", idfase=idfase, filtro = request.form["filtro"]))
    if request.method == "GET":
        iditem = request.args.getlist("iditem")[0]
        item = itemMgr.getItem(iditem)
        tipoItem = tipoItemMgr.getTipoItem(item.idtipoitem)
        idfase = request.args.getlist("idfase")[0]
        return render_template("eliminarItem.html", tipoItem=tipoItem,item=item, idfase=idfase, filtro= request.args.getlist("filtro")[0])

def aprobarItem():
    """ Metodo encargado de aprobar un item """
    
    if request.method == "POST":
        iditem = request.form["iditem"]
        item=itemMgr.getItem(iditem)
        enLB=True
        for relacion in item.padres:
            temp= relacion.item1
            if temp.fase.numero < item.fase.numero:
#                 si la linea base no esta aprobada
                if temp.idestadoitem != 4:
                    enLB=False
                    flash("El item:" + temp.nombre +" debe estar en una linea base aprobada", "error")
            else:
                if temp.idestadoitem != 2 and temp.idestadoitem != 4:
                    flash("El item: "+ temp.nombre + " debe estar aprobado o en una linea base aprobada", "error")
                    enLB=False 
        if enLB:
            crearHistorial(item)
            item.idestadoitem=2
            item.version = int(item.version) + 1
            item.fechaultimamod = datetime.date.today() 
            usuario=session["username"]
            usuarioUltimaMod = usuarioMgr.getUsuarioPorUser(usuario)
            item.usuarioUltimaMod= usuarioUltimaMod
            itemMgr.guardarItem(item)
            idfase = request.form["idfase"]
            session["_flashes"]=[]
            flash("Item aprobado exitosamente")
        return redirect(url_for("abmItem", idfase=item.fase.idfase, filtro = request.form["filtro"]))
    if request.method == "GET":
        iditem = request.args.getlist("iditem")[0]
        item = itemMgr.getItem(iditem)
        tipoItem = tipoItemMgr.getTipoItem(item.idtipoitem)
        idfase = request.args.getlist("idfase")[0]
        return render_template("aprobarItem.html", tipoItem=tipoItem,item=item, idfase=idfase, filtro= request.args.getlist("filtro")[0])

def restaurarItem():
    """ Metodo encargado de restaurar un item """
    
    if request.method == "POST":
        idhistorial= request.form["check"]
        iditem = request.form["iditem"]
        item=itemMgr.getItem(iditem)
        crearHistorial(item)
        historial= historialMgr.getHistorialItem(idhistorial)
        restaurarHistorial(item, historial)
        session["_flashes"]=[]
        flash("Item restaurado exitosamente")
        return redirect(url_for("abmItem", idfase=item.fase.idfase, filtro = ""))
    if request.method == "GET":
        iditem = request.args.getlist("iditem")[0]
        item = itemMgr.getItem(iditem)
        idfase = request.args.getlist("idfase")[0]
        return render_template("restaurarItem.html", item=item, idfase=idfase, filtro= request.args.getlist("filtro")[0])


def consultarItem():
    """ Metodo encargado de consultar los datos de un item """
    
    if request.method == "GET":
        iditem = request.args.getlist("iditem")[0]
        item = itemMgr.getItem(iditem)
        tipoItem = tipoItemMgr.getTipoItem(item.idtipoitem)
        idfase = request.args.getlist("idfase")[0]
        return render_template("consultarItem.html", tipoItem=tipoItem,idfase=idfase, item = item, filtro = request.args.getlist("filtro")[0])
    else:
        idfase = request.form["idfase"]
        iditem = request.form["iditem"]
        item = itemMgr.getItem(iditem)
        idarchivo = request.form["idarchivo"]
        if request.form['boton_item']=='Descargar':
            #print "entro a descargar archivo"
            archivos = item.adjuntos
            if archivos:
                for archivo in archivos:
                    if archivo.idadjunto == int(idarchivo):
                        archivoF = archivo
                if archivoF: 
                    data = archivoF.archivo
                    name = archivoF.nombre
                    f=open(name,'wb')
                    f.write(data)
                    f.close()
                    with open(name, 'rb') as f:
                        response = make_response(f.read())
                        response.headers['Cache-Control'] = 'no-cache'
                        response.headers['Content-Type'] = "application/download" 
                        response.headers['Content-Type'] = "application/force-download"
                        response.headers['Content-Type'] = "application/pdf"
                        response.headers['Content-Type'] = "application/octet-stream"
                        response.headers['X-Accel-Redirect'] = f.name
                        response.headers['Content-Transfer-Encoding'] = 'binary'
                        response.headers['Content-Disposition'] = "inline; filename="+f.name
                        os.remove(f.name)
                        return response
            else:
                flash("No posee archivos asociados")
                return redirect(url_for('abmItem', idfase=idfase, filtro=""))   
        elif request.form['boton_item']=='Aceptar':
            return redirect(url_for("abmItem", idfase=idfase, filtro=""))

def modificarRelacion():
    """ Metodo encargado de modificar una relacion entre items"""
    if request.method == "GET":
        pagina=1
        if request.args.getlist("pagina"):
            pagina=request.args.getlist("pagina")[0]
        
        iditem = request.args.getlist("iditem")[0]
        nroFase = request.args.getlist("nroFase")[0]
        filtro = request.args.getlist("filtro")[0]
        return paginarRelacion(iditem, pagina, filtro, nroFase)
#         return render_template("modificarRelacion.html", nroFase=nroFase, item= item, itemsRelacion= itemsRelacion, lista= lista)
    if request.method == "POST":
        iditem = request.form["iditem"]
        if request.form.getlist("check"):
            iditemRelacion = request.form.getlist("check")[0]
            item = itemMgr.getItem(iditem)
            itemRelacion= itemMgr.getItem(iditemRelacion)
            if item.fase.numero == itemRelacion.fase.numero:
                idtipoRelacion = 1
            else:
                idtipoRelacion = 2
            tipoRelacion = tipoRelacionMgr.getTipoRelacion(idtipoRelacion)
            G=nx.DiGraph()
            relaciones=relacionMgr.getRelaciones()
            for rel in relaciones:
                G.add_edge(rel.item1.iditem, rel.item2.iditem)

            G.add_edge(itemRelacion.iditem, item.iditem)
            if len(nx.simple_cycles(G)) > 0:
                session["_flashes"]=[]
                flash("No se pueder agregar esta relacion debido a que forma un ciclo dentro del proyecto", "error")
                return redirect(url_for('modificarRelacion', exito="no", iditem=item.iditem, filtro=request.form["filtro"], nroFase=item.fase.numero))
            else:
                relacion = Relacion(item1 = itemRelacion, item2= item, tipo= tipoRelacion)
                crearHistorial(item)
                item.version = int(item.version) + 1
                item.fechaultimamod = datetime.date.today() 
                usuario=session["username"]
                usuarioUltimaMod = usuarioMgr.getUsuarioPorUser(usuario)
                item.usuarioUltimaMod= usuarioUltimaMod
                itemMgr.guardarItem(item)
                relacionMgr.guardarRelacion(relacion) 
                session["_flashes"]=[]
                flash("Relacion agregada existosamente")
                return redirect(url_for('modificarRelacion', exito="si",iditem=item.iditem, filtro=request.form["filtro"], nroFase=item.fase.numero))
        else:
            return paginarModificarIntegrante(idproyecto, 1, "")

        mensajes = get_flashed_messages(with_categories= True)
        categoria, mensaje = mensajes[0]
        if categoria == "error":
            flash(mensaje, categoria)
        else:
            flash("Modificado exitosamente");
        return redirect(url_for("abmItem", idfase=item.fase.idfase, filtro=""))

def eliminarRelacion():
    """ Metodo encargado de eliminar un una relacion entre items """
    if request.method == "GET":        
        iditem = request.args.getlist("iditem")[0]
        nroFase = request.args.getlist("nroFase")[0]
        filtro = request.args.getlist("filtro")[0]
        item = itemMgr.getItem(iditem)
        return render_template("eliminarRelacion.html", item= item)
#         return render_template("modificarRelacion.html", nroFase=nroFase, item= item, itemsRelacion= itemsRelacion, lista= lista)
    if request.method == "POST":
        iditem = request.form["iditem"]
        if request.form.getlist("check"):
#             iditemRelacion = request.form.getlist("check")[0]
            rel = request.form.getlist("check")[0].split("/")
            tipo = rel[0]
            iditemRelacion= rel[1]
            item = itemMgr.getItem(iditem)
            crearHistorial(item)
            if tipo == "izq":
                relacionMgr.eliminarRelacion(iditem, iditemRelacion)            
            else:
                relacionMgr.eliminarRelacion(iditemRelacion, iditem) 
            
            item.version = int(item.version) + 1
            item.fechaultimamod = datetime.date.today() 
            usuario=session["username"]
            usuarioUltimaMod = usuarioMgr.getUsuarioPorUser(usuario)
            item.usuarioUltimaMod= usuarioUltimaMod
            itemMgr.guardarItem(item)
            session["_flashes"]=[]
            flash("Relacion eliminada exitosamente");           
            return redirect(url_for('eliminarRelacion', iditem=item.iditem, filtro="", nroFase=item.fase.numero))

        return redirect(url_for("abmItem", idfase=item.fase.idfase, filtro=""))


def paginarItem(idfase, fase, pagina, filtro):
    """ Metodo encargado de la busqueda de item a partir de un filtro """
    porPagina= 5
    pagina = int(pagina)
    total = itemMgr.getItemPaginado(idfase, nombre=filtro, desde=None, hasta=None)
    if total % porPagina == 0:
        cantPaginas= total/porPagina
    else:
        resto = total % porPagina
        subtotal = (total-resto)
        cantPaginas= (subtotal/porPagina) + 1
    hasta = pagina * porPagina
    desde = hasta - porPagina
    items = itemMgr.getItemPaginado(idfase, filtro, desde, hasta)
    return render_template("abmItem.html", lista = items, idfase = idfase, fase =fase,\
        filtro = filtro, form=request.form, primera=1, ultima= cantPaginas, ant= pagina-1,\
        sig=pagina +1, cantPaginas = cantPaginas, pagina = pagina)


def paginarRelacion(iditem, pagina, filtro, nroFase):
    """ Metodo encargado de la busqueda de relaciones a partir de un filtro """
    porPagina= 5
    pagina = int(pagina)
    total = itemMgr.getItemsParaRelacionPaginado(idproyecto= session["idproyecto"], nroFase=nroFase, nombre=filtro, desde=None, hasta=None)
    if total % porPagina == 0:
        cantPaginas= total/porPagina
    else:
        resto = total % porPagina
        subtotal = (total-resto)
        cantPaginas= (subtotal/porPagina) + 1
    hasta = pagina * porPagina
    desde = hasta - porPagina
    item = itemMgr.getItem(iditem)
#     itemsRelacion.add(item.hijos)
    items = itemMgr.getItemsParaRelacionPaginado(idproyecto= session["idproyecto"], nroFase= nroFase, nombre=filtro, desde=desde, hasta=hasta)
            
    return render_template("modificarRelacion.html", lista = items,\
        item= item, nroFase=nroFase, filtro = filtro, primera=1, ultima= cantPaginas, ant= pagina-1,\
        sig=pagina +1, cantPaginas = cantPaginas, pagina = pagina)

def crearHistorial(item):
    """ Metodo encargado de crear el historial de un item """
    historial = HistorialItem()
    historial.item= item
    historial.nombre= item.nombre
    historial.costo= item.costo
    historial.complejidad = item.complejidad
    historial.fechainicio= item.fechainicio
    historial.fechafin = item.fechafin
    historial.version = item.version
    historial.numeroitem= item.numeroitem
    historial.duracion = item.duracion
    historial.fechaultimamod= item.fechaultimamod

    historial.fase= item.fase
    historial.estadoItem= item.estadoItem
    historial.tipoItem = item.tipoItem
    historial.usuarioUltimaMod= item.usuarioUltimaMod
    historial.creador = item.creador
    historial.usuarioHabilitado = item.usuarioHabilitado
    historial.lineaBase = item.lineaBase
    historialMgr.guardarHistorialItem(historial)

#Guarda en el historial de relaciones, padres e hijos  
    for hijos in item.hijos:
        historialRelacion= HistorialRelacion()
        historialRelacion.idhistorialitem=historial.idhistorialitem
        historialRelacion.iditem1=hijos.iditem1
        historialRelacion.iditem2=hijos.iditem2
        historialRelacion.idtipo= hijos.idtipo
        historialRelacionMgr.guardarHistorialRelacion(historialRelacion)
        
    for padres in item.padres:
        historialRelacion= HistorialRelacion()
        historialRelacion.idhistorialitem=historial.idhistorialitem
        historialRelacion.iditem1=padres.iditem1
        historialRelacion.iditem2=padres.iditem2
        historialRelacion.idtipo= padres.idtipo
        historialRelacionMgr.guardarHistorialRelacion(historialRelacion)
#Guarda el historial de atributos de item
    for atributo in item.atributositem:
        historialAtributo= HistorialAtributo()
        historialAtributo.idhistorialitem=historial.idhistorialitem
        historialAtributo.idatributoitem=atributo.idatributoitem
        historialAtributo.idatributotipo=atributo.idatributotipo
        historialAtributo.valor=atributo.valor
        historialAtributo.iditem=atributo.iditem
        historialAtributoMgr.guardarHistorialAtributo(historialAtributo)
 
    historialMgr.guardarHistorialItem(historial)
    item.idestadoitem=1

def restaurarHistorial(item, historial):
    """ Metodo encargado de restaurar el historial de un item """
    crearHistorial(item)
    item.nombre= historial.nombre
    item.costo= historial.costo
    item.complejidad = historial.complejidad
    item.fechainicio= historial.fechainicio
    item.fechafin = historial.fechafin
    item.version = int(item.version) + 1
    item.numeroitem= historial.numeroitem
    item.duracion = historial.duracion
    item.fechaultimamod= historial.fechaultimamod
    hijos = historialRelacionMgr.getHijos(historial)
#restaurar las relaciones, falta controlar ciclos al restaurar
    for itemHijos in item.hijos:
        relacionMgr.eliminarRelacion(iditem1=itemHijos.iditem1, iditem2=itemHijos.iditem2)
    for itemPadres in item.hijos:
        relacionMgr.eliminarRelacion(iditem1= iditemPadres.iditem1, iditem2 =iditemPadres.iditem2)
    
    for hijo in hijos:
        relacion= Relacion()
        relacion.iditem1= hijo.iditem1
        relacion.iditem2= hijo.iditem2
        relacion.idtipo= hijo.idtipo
        item.hijos.append(relacion)
        
    padres = historialRelacionMgr.getPadres(historial)
    for padre in padres:
        relacion= Relacion()
        relacion.iditem1= padre.iditem1
        relacion.iditem2= padre.iditem2
        relacion.idtipo= padre.idtipo
        item.hijos.append(relacion)
#falta traer atributos de item  
     
    historialAtributos= historialAtributoMgr.getHistorialAtributos(historial.idhistorialitem)
    if historialAtributos:
        for atributo in historialAtributos:
            for atributositem in item.atributositem:
                if atributo.idatributoitem==atributositem.idatributoitem:
                    atributositem.valor=atributo.valor
    
    item.fechaultimamod = datetime.date.today() 
    usuario=session["username"]
    usuarioUltimaMod = usuarioMgr.getUsuarioPorUser(usuario)
    item.usuarioUltimaMod= usuarioUltimaMod

    item.fase= historial.fase
    item.estadoItem= historial.estadoItem
    item.tipoItem = historial.tipoItem
    item.creador = historial.creador
    item.usuarioHabilitado = historial.usuarioHabilitado
    item.lineaBase = historial.lineaBase
    itemMgr.guardarItem(item)

def cargarAtributos():
    """ Metodo encargado de cargar los atributos a un item """
    if request.method == "GET":
        iditem=""
        if request.args.getlist("iditem"):
            iditem=request.args.getlist("iditem")[0]
        item = itemMgr.getItem(iditem)
        return render_template("cargarAtributos.html", item=item)
    
    if request.method == "POST":
        iditem=request.form["iditem"]
        item= itemMgr.getItem(iditem)
        crearHistorial(item)
        tipoItem =item.tipoItem
        if item.atributositem:
            for atributo in tipoItem.atributos:
                campo=request.form[atributo.campo]
                for atri in item.atributositem:
                    if atri.atributotipo.idatributotipo == atributo.idatributotipo:
                        atri.valor=campo;  
        else:
            for atributo in tipoItem.atributos:
                campo=request.form[atributo.campo]
                atributoItem= AtributoItem(valor=campo)
                atributoItem.atributotipo=atributo
                atributoItem.item=item
        
        item.fechaultimamod = datetime.date.today() 
        usuario=session["username"]
        usuarioUltimaMod = usuarioMgr.getUsuarioPorUser(usuario)
        item.usuarioUltimaMod= usuarioUltimaMod
        item.version = int(item.version) + 1
        itemMgr.guardarItem(item)
        session["_flashes"]=[]
        flash("Atributos cargados exitosamente") 
        return redirect(url_for("abmItem", idfase=item.fase.idfase, filtro=""))
     
def verRelacionesProyecto():
    """ Metodo encargado de mostrar las relaciones entre items de un proyecto """
    if request.method == "GET":    
        clusters=[]
        idproyecto=session["idproyecto"]
        fases= faseMgr.getFasesPorProyecto(idproyecto)
        grafo= pydot.Dot(graph_type='digraph', graph_name="principal", label="\"" + 'Relaciones del proyecto: '+fases[0].proyecto.nombre+' '+"\"", fontsize='10', size='100', bgcolor="#A9B5A2", rankdir='LR', labelloc='t',labeljust='l', ranksep='0.4')
        grafo.set_node_defaults(fontsize='8')
        i=0 
        for fase in fases:
            clusters.append(pydot.Cluster(graph_name=fase.nombre, bgcolor="#85aADD",rankdir="LR", ranksep='1', label='fase'+str(i+1), fontsize='8'))        
            cluster=clusters[i]
            i= i+1
            items=itemMgr.getItemsPorFaseOrderId(fase.idfase)
            estilo='filled'
            color='black'
            lineasbase= lineaBaseMgr.getLineaBasePorFase(fase.idfase)
            j=0
            for lineaBase in lineasbase:
                j=j+1
                if lineaBase.estadoLB.nombre=='aprobada':
                    color='#801CAB'#lila
                elif lineaBase.estadoLB.nombre=='en revision': 
                    color='#F39923'#naranja
                elif lineaBase.estadoLB.nombre=='rota':
                    color='#E42E0A'#rojo
                elif lineaBase.estadoLB.nombre=='abierta':
                    color='#F7F7F7'#blanco
                 
                clusterLinea=pydot.Cluster(str(lineaBase.idlineabase), label=str(j), color=color, style="dashed");
                for item in lineaBase.items:
                    clusterLinea.add_node(pydot.Node(str(item.nombre), style=estilo, color='#801CAB'))

                cluster.add_subgraph(clusterLinea);
                
            for item in items:
                if item.usuarioHabilitado:
                     color='#E42E0A'#rojo
                else:
                    if item.estadoItem.nombre=='pendiente':
                        color='#DCEF30'#amarillo
                    elif item.estadoItem.nombre=='aprobado':
                        color='#30B62B'#verde
                    elif item.estadoItem.nombre=='en revision': 
                        color='#F39923'#naranja
                    elif item.estadoItem.nombre=='en lineabase':
                        color='#801CAB'#lila
                    elif item.estadoItem.nombre=='creado':
                        color='#F7F7F7'#blanco

                cluster.add_node(pydot.Node(str(item.nombre), style=estilo, color=color))
            grafo.add_subgraph(cluster)
            
        relacionesProyecto=relacionMgr.getRelacionesProyecto(fase.proyecto.idproyecto)
        for relacion in relacionesProyecto:
            grafo.add_edge(pydot.Edge(str(relacion.item1.nombre),str(relacion.item2.nombre)))
        
        import time;
        t=str(time.time())
        #print sys.path[0]
        if app.config['DEV'] == True:
            imagepath = "epm/static/"
            print imagepath
        else:
            imagepath = sys.path[0]+"/is2-epm/epm/static/"
            print imagepath
        grafo.write_png(imagepath+t+'ld_graph.png')
        html="<div><img src='/static/"+t+"ld_graph.png'/></div><script type='text/javascript'>window.parent.leftFrame.document.getElementById('leyenda').style.display='block'</script>"
#         html=html+"<div><img src='/static/images/Estados.png'/></div>"
        #return render_pdf(HTML(string=html))
        return html;
        return redirect(url_for("abmItem", idfase=idfase, filtro=""))

def verRelacionesFase():
    """ Metodo encargado de mostrar las relaciones entre items de una fase """
    if request.method == "GET":
        idfase=session["idfase"]
              
        clusters=[]
        fase=faseMgr.getFase(idfase) 
        grafo= pydot.Dot(graph_type='digraph', graph_name="principal", label="\"" + 'Relaciones de la fase: '+fase.nombre+' '+"\"" , fontsize='10', size='100', bgcolor="#A9B5A2", rankdir='LR', labelloc='t',labeljust='l', ranksep='0.4')
        grafo.set_node_defaults(fontsize='8')
         
        cluster = pydot.Cluster(graph_name=fase.nombre, bgcolor="#85aADD",rankdir="LR", ranksep='1', label='fase'+str(fase.numero), fontsize='8')        
        items=itemMgr.getItemsPorFaseOrderId(fase.idfase)
        estilo='filled'
        color='black'
        lineasbase= lineaBaseMgr.getLineaBasePorFase(fase.idfase)
        j=0 
         
        for lineaBase in lineasbase:
            j=j+1
            if lineaBase.estadoLB.nombre=='aprobada':
                color='#801CAB'#lila
            elif lineaBase.estadoLB.nombre=='en revision': 
                color='#F39923'#naranja
            elif lineaBase.estadoLB.nombre=='rota':
                color='#E42E0A'#rojo
            elif lineaBase.estadoLB.nombre=='abierta':
                color='#F7F7F7'#blanco
             
            clusterLinea=pydot.Cluster(str(lineaBase.idlineabase), label=str(j), color=color, style="dashed");
            for item in lineaBase.items:
                clusterLinea.add_node(pydot.Node(str(item.nombre), style=estilo, color='#801CAB'))
 
            cluster.add_subgraph(clusterLinea);
                 
        for item in items:
            if item.usuarioHabilitado:
                 color='#E42E0A'#rojo
            else:
                if item.estadoItem.nombre=='pendiente':
                    color='#DCEF30'#amarillo
                elif item.estadoItem.nombre=='aprobado':
                    color='#30B62B'#verde
                elif item.estadoItem.nombre=='en revision': 
                    color='#F39923'#naranja
                elif item.estadoItem.nombre=='en lineabase':
                    color='#801CAB'#lila
                elif item.estadoItem.nombre=='creado':
                    color='#F7F7F7'#blanco
            cluster.add_node(pydot.Node(str(item.nombre), style=estilo, color=color))

        grafo.add_subgraph(cluster)
            
        relacionesProyecto=relacionMgr.getRelacionesProyecto(fase.proyecto.idproyecto)
        for relacion in relacionesProyecto:
            if relacion.item1.fase.idfase== fase.idfase and relacion.item2.fase.idfase==fase.idfase:
                grafo.add_edge(pydot.Edge(str(relacion.item1.nombre),str(relacion.item2.nombre)))
        
        import time;
        t=str(time.time())
        #print sys.path[0]
        if app.config['DEV'] == True:
            imagepath = "epm/static/"
            print imagepath
        else:
            imagepath = sys.path[0]+"/is2-epm/epm/static/"
            print imagepath
        grafo.write_png(imagepath+t+'ld_graph.png')
        html="<div><img src='/static/"+t+"ld_graph.png'/></div><script type='text/javascript'>window.parent.leftFrame.document.getElementById('leyenda').style.display='block'</script>"
#         html=html+"<div><img src='/static/images/Estados.png'/></div>"
        #return render_pdf(HTML(string=html))
        return html;

def verRelacionesItem():
    """ Metodo encargado de mostrar las relaciones de un item"""
    if request.method == "GET":
        iditem=request.args.getlist("iditem")[0]
        item= itemMgr.getItem(iditem)
        grafo= pydot.Dot(graph_type='digraph', graph_name="principal", label= "\"" + 'Relaciones del item: '+item.nombre+' '+"\"", fontsize='10', size='100', bgcolor="#A9B5A2", rankdir='LR', labelloc='t',labeljust='l', ranksep='0.4')
        grafo.set_node_defaults(fontsize='8')    
        
        itemsRelacion=[]
        for padre in item.padres:
            itemsRelacion.append(padre.item1)
          
        for hijo in item.hijos:   
            itemsRelacion.append(hijo.item2)
        
        fases=[]
        for itemRelacion in itemsRelacion:
            if itemRelacion.fase not in fases:
                fases.append(itemRelacion.fase)

        grafoFases=[]  
        for fase in fases:
            clusterFase = pydot.Cluster(graph_name=fase.nombre, bgcolor="#85aADD",rankdir="LR", ranksep='1', label='fase'+str(fase.numero), fontsize='8')        
            for itemRelacion in itemsRelacion:
                if itemRelacion in fase.items:
                    if itemRelacion.usuarioHabilitado:
                        color='#E42E0A'#rojo
                    else:
                        if itemRelacion.estadoItem.nombre=='pendiente':
                            color='#DCEF30'#amarillo
                        elif itemRelacion.estadoItem.nombre=='aprobado':
                            color='#30B62B'#verde
                        elif itemRelacion.estadoItem.nombre=='en revision': 
                            color='#F39923'#naranja
                        elif itemRelacion.estadoItem.nombre=='en lineabase':
                            color='#801CAB'#lila
                        elif itemRelacion.estadoItem.nombre=='creado':
                            color='#F7F7F7'#blanco
             
                    clusterFase.add_node(pydot.Node(str(itemRelacion.nombre), style='filled', color=color))    
             
            grafo.add_subgraph(clusterFase)        
        
        clusterFaseDelItem= pydot.Cluster(graph_name=item.fase.nombre, bgcolor="#4949D2",rankdir="LR", ranksep='1', label='fase'+str(item.fase.numero), fontsize='8')
        if item.usuarioHabilitado:
            color='#E42E0A'#rojo
        else:
            if item.estadoItem.nombre=='pendiente':
                color='#DCEF30'#amarillo
            elif item.estadoItem.nombre=='aprobado':
                color='#30B62B'#verde
            elif item.estadoItem.nombre=='en revision': 
                color='#F39923'#naranja
            elif item.estadoItem.nombre=='en lineabase':
                color='#801CAB'#lila
            elif item.estadoItem.nombre=='creado':
                color='#F7F7F7'#blanco
             
        clusterFaseDelItem.add_node(pydot.Node(str(item.nombre), style='filled', color=color))  
        
        grafo.add_subgraph(clusterFaseDelItem) 
         
        relacionesItem=[]
        for padre in item.padres:
            relacionesItem.append(padre)
          
        for hijo in item.hijos:   
            relacionesItem.append(hijo)
         
        for relacion in relacionesItem:
            grafo.add_edge(pydot.Edge(str(relacion.item1.nombre),str(relacion.item2.nombre)))
             
        import time;
        t=str(time.time())
        #print sys.path[0]
        if app.config['DEV'] == True:
            imagepath = "epm/static/"
            print imagepath
        else:
            imagepath = sys.path[0]+"/is2-epm/epm/static/"
            print imagepath
        grafo.write_png(imagepath+t+'ld_graph.png')
        html="<div><img src='/static/"+t+"ld_graph.png'/></div><script type='text/javascript'>window.parent.leftFrame.document.getElementById('leyenda').style.display='block'</script>"
#         html=html+"<div><img src='/static/images/Estados.png'/></div>"
        #return render_pdf(HTML(string=html))
        return html;


def obtenerFamilia(familia, item):
    if item:
        if item not in familia:
            familia.append(item)
            for hijo in item.hijos:
                obtenerFamilia(familia, hijo.item2)
            for padre in item.padres:
                obtenerFamilia(familia, padre.item1)

def verFamiliaItem():
    """ Metodo encargado de mostrar los items involucrados y las relaciones de una fase """
    if request.method == "GET":
        iditem=request.args.getlist("iditem")[0]
        item= itemMgr.getItem(iditem)
        grafo= pydot.Dot(graph_type='digraph', graph_name="principal", label="\"" + 'Familia del item: '+item.nombre+' '+"\"", fontsize='10', size='100', bgcolor="#A9B5A2", rankdir='LR', labelloc='t',labeljust='l', ranksep='0.4')
        grafo.set_node_defaults(fontsize='8')    
        familia=[]
        obtenerFamilia(familia, item)
        itemsRelacion=familia
                
        fases=[]
        for itemRelacion in itemsRelacion:
            if itemRelacion.fase not in fases:
                fases.append(itemRelacion.fase)
 
        grafoFases=[]  
        for fase in fases:
            clusterFase = pydot.Cluster(graph_name=fase.nombre, bgcolor="#85aADD",rankdir="LR", ranksep='1', label='fase'+str(fase.numero), fontsize='8')        
            for itemRelacion in itemsRelacion:
                if itemRelacion in fase.items:
                    if itemRelacion.usuarioHabilitado:
                        color='#E42E0A'#rojo
                    else:
                        if itemRelacion.estadoItem.nombre=='pendiente':
                            color='#DCEF30'#amarillo
                        elif itemRelacion.estadoItem.nombre=='aprobado':
                            color='#30B62B'#verde
                        elif itemRelacion.estadoItem.nombre=='en revision': 
                            color='#F39923'#naranja
                        elif itemRelacion.estadoItem.nombre=='en lineabase':
                            color='#801CAB'#lila
                        elif itemRelacion.estadoItem.nombre=='creado':
                            color='#F7F7F7'#blanco
             
                    clusterFase.add_node(pydot.Node(str(itemRelacion.nombre), style='filled', color=color))    
             
            grafo.add_subgraph(clusterFase)        
                
        relacionesItem=relacionMgr.getRelacionesProyecto(item.fase.proyecto.idproyecto)
         
        for relacion in relacionesItem:
            if relacion.item1 in itemsRelacion or relacion.item2 in itemsRelacion:
                grafo.add_edge(pydot.Edge(str(relacion.item1.nombre),str(relacion.item2.nombre)))
             
        import time;
        t=str(time.time())
        #print sys.path[0]
        if app.config['DEV'] == True:
            imagepath = "epm/static/"
            print imagepath
        else:
            imagepath = sys.path[0]+"/is2-epm/epm/static/"
            print imagepath
        grafo.write_png(imagepath+t+'ld_graph.png')
        html="<div><img src='/static/"+t+"ld_graph.png'/></div><script type='text/javascript'>window.parent.leftFrame.document.getElementById('leyenda').style.display='block'</script>"
#         html=html+"<div><img src='/static/images/Estados.png'/></div>"
        #return render_pdf(HTML(string=html))
        return html;
 

def revivirItem():
    """ Metodo encargado de revivir un item de la base de datos """
    
    if request.method == "POST":
        iditem= request.form["check"]
        item=itemMgr.getItem(iditem)
        crearHistorial(item)
        item.idestadoitem=1
        item.version = int(item.version) + 1
        item.fechaultimamod = datetime.date.today() 
        usuario=session["username"]
        usuarioUltimaMod = usuarioMgr.getUsuarioPorUser(usuario)
        item.usuarioUltimaMod= usuarioUltimaMod
        itemMgr.guardarItem(item)
        fase=faseMgr.getFase(item.fase.idfase)
        fase.cant_items= fase.cant_items+1
        faseMgr.guardarFase(fase)
        session["_flashes"]=[]
        flash("Item revivido exitosamente")
        return redirect(url_for("abmItem", idfase=item.fase.idfase, filtro = ""))
    if request.method == "GET":
        idfase = request.args.getlist("idfase")[0]
        idproyecto= session["idproyecto"]
        fase= faseMgr.getFase(idfase)
        items = itemMgr.getItemsEliminadoDelProyecto(idproyecto=idproyecto, nombre="", desde=0, hasta=100)
        return render_template("revivirItem.html", items=items, fase= fase, idfase=idfase, filtro= "")
 
def cargaTipoItem():
    """ Metodo encargado de cargar el tipo de item"""
    if request.method=="GET":
        idtipoitem= request.args.getlist("tipoitem")[0]
        idproyecto= session["idproyecto"]
        tipoItem= tipoItemMgr.getTipoItem(idtipoitem)
        numero = itemMgr.getNumeroItemDelProyecto(idproyecto, idtipoitem)
        
        return str(numero)
 
ALLOWED_EXTENSIONS = set(['txt','TXT' ,'pdf', 'PDF', 'png','PNG', 'jpg', 'JPG', 'jpeg',
                          'JPEG', 'gif','GIF','odt','ODT'])

def carga_archivo(iditem,file):
    nombre = file.filename
    arc = file.read() 
    a = Adjunto(nombre=nombre, descripcion="Carga de archivo", archivo=arc)
    item = itemMgr.getItem(iditem)
    a.item = item
    adjuntoMgr.guardarAdjunto(a)
    return 'Exito'

def allowed_file(filename):
    return '.' in filename and \
           filename.rsplit('.', 1)[1] in ALLOWED_EXTENSIONS

def itemsEnSC():
    """ Metodo encargado de listar los items en solicitud de cambio """
    if request.method == "GET":
        idfase= session["idfase"]
        idproyecto= session['idproyecto']
        if session['idfase']:
            filtro="" 
            if request.args.getlist("filtro"):
                filtro = request.args.getlist("filtro")[0]
            pagina = 1
            if request.args.getlist("pagina"):
                pagina = request.args.getlist("pagina")[0]
            idfase = session['idfase']
            fase = faseMgr.getFase(idfase)
            return paginarItemPorSC(idfase, pagina , filtro)
        else:
            if session['idproyecto']:
                flash(u"Seleccionar una fase del proyecto antes de realizar la operaci\u00f3n", "error")
            else:
                flash(u"Seleccionar un proyecto antes de realizar la operaci\u00f3n", "error")
            return redirect(url_for("configurarFase", action= "itemsEnSC"))
        
    if request.method == "POST":
        idfase = session['idfase']
        filtro= request.form["filtro"]
        return paginarItemPorSC(idfase, 1 , filtro)


def modificarItemPorSC():
    """ Metodo encargado de modificar un item """
    
    if request.method == "GET":
        iditem = request.args.getlist("iditem")[0]
        item = itemMgr.getItem(iditem)
        return render_template("modificarItemPorSC.html", item = item )    
        
    if request.method == "POST":
        iditem = request.form["iditem"]
        item = itemMgr.getItem(iditem)
        
        crearHistorial(item)
        item.nombre = request.form["nombre"]
        item.costo = request.form["costo"]
        idfase = session["idfase"]
        item.complejidad = request.form["complejidad"]
        item.fechainicio = request.form["fechaini"]
        item.fechafin = request.form["fechafin"]
        item.duracion = request.form["duracion"]
        item.version = int(request.form["version"]) + 1
        item.numeroitem = request.form["numeroitem"]
        item.idtipoitem = request.form["idtipoitem"]  
        item.fechaultimamod = datetime.date.today() 
        usuario=session["username"]
        usuarioUltimaMod = usuarioMgr.getUsuarioPorUser(usuario)
        item.usuarioUltimaMod= usuarioUltimaMod
        item.usuarioHabilitado= None
        
        solicitud= item.solicitudes[0]
        votos = solicitud.votos
        for voto in votos:
            votosMgr.eliminarVoto(voto.idvoto)
            
        solicitudMgr.eliminarSolicitudCambio(solicitud.idsolicitud)
        session["_flushes"]=[]
        itemMgr.guardarItem(item)
        mensajes = get_flashed_messages(with_categories= True)
        categoria, mensaje = mensajes[0]
        if categoria == "error":
            flash(mensaje, categoria)
        else:
            flash("Modificado exitosamente");
            
        return redirect(url_for("itemsEnSC"))


def modificarRelacionPorSC():
    """ Metodo encargado de modificar las relaciones de un item en solicitud de cambio """
    if request.method == "GET":
        pagina=1
        if request.args.getlist("pagina"):
            pagina=request.args.getlist("pagina")[0]
        
        iditem = request.args.getlist("iditem")[0]
        nroFase = request.args.getlist("nroFase")[0]
        filtro = request.args.getlist("filtro")[0]
        return paginarRelacionPorSC(iditem, pagina, filtro, nroFase)
#         return render_template("modificarRelacion.html", nroFase=nroFase, item= item, itemsRelacion= itemsRelacion, lista= lista)
    if request.method == "POST":
        iditem = request.form["iditem"]
        if request.form.getlist("check"):
            iditemRelacion = request.form.getlist("check")[0]
            item = itemMgr.getItem(iditem)
            
            itemRelacion= itemMgr.getItem(iditemRelacion)
            if item.fase.numero == itemRelacion.fase.numero:
                idtipoRelacion = 1
            else:
                idtipoRelacion = 2
            tipoRelacion = tipoRelacionMgr.getTipoRelacion(idtipoRelacion)
            G=nx.DiGraph()
            relaciones=relacionMgr.getRelaciones()
            for rel in relaciones:
                G.add_edge(rel.item1.iditem, rel.item2.iditem)

            G.add_edge(itemRelacion.iditem, item.iditem)
            if len(nx.simple_cycles(G)) > 0:
                session["_flashes"]=[]
                flash("No se pueder agregar esta relacion debido a que forma un ciclo dentro del proyecto", "error")
                return redirect(url_for('modificarRelacionPorSC', iditem=item.iditem, filtro=request.form["filtro"], nroFase=item.fase.numero))
            else:
                relacion = Relacion(item1 = itemRelacion, item2= item, tipo= tipoRelacion)
                
                session["_flushes"]=[] 
                crearHistorial(item)
                item.version = int(item.version) + 1
                item.fechaultimamod = datetime.date.today() 
                usuario=session["username"]
                usuarioUltimaMod = usuarioMgr.getUsuarioPorUser(usuario)
                item.usuarioUltimaMod= usuarioUltimaMod
                item.usuarioHabilitado=None
                solicitud= item.solicitudes[0]
                votos = solicitud.votos
                for voto in votos:
                    votosMgr.eliminarVoto(voto.idvoto)
                solicitudMgr.eliminarSolicitudCambio(solicitud.idsolicitud)
              
                itemMgr.guardarItem(item)
                relacionMgr.guardarRelacion(relacion) 
                session["_flashes"]=[]
                flash("Relacion agregada existosamente")
                return redirect(url_for('modificarRelacionPorSC', iditem=item.iditem, filtro=request.form["filtro"], nroFase=item.fase.numero))
        else:
            return paginarModificarIntegrante(idproyecto, 1, "")

        mensajes = get_flashed_messages(with_categories= True)
        categoria, mensaje = mensajes[0]
        if categoria == "error":
            flash(mensaje, categoria)
        else:
            flash("Modificado exitosamente");
        return redirect(url_for("abmItem", idfase=item.fase.idfase, filtro=""))


def paginarRelacionPorSC(iditem, pagina, filtro, nroFase):
    """ Metodo encargado de la busqueda de relaciones de items en solicitud a partir de un filtro """
    porPagina= 5
    pagina = int(pagina)
    total = itemMgr.getItemsParaRelacionPaginado(idproyecto= session["idproyecto"], nroFase=nroFase, nombre=filtro, desde=None, hasta=None)
    if total % porPagina == 0:
        cantPaginas= total/porPagina
    else:
        resto = total % porPagina
        subtotal = (total-resto)
        cantPaginas= (subtotal/porPagina) + 1
    hasta = pagina * porPagina
    desde = hasta - porPagina
    item = itemMgr.getItem(iditem)
#     itemsRelacion.add(item.hijos)
    items = itemMgr.getItemsParaRelacionPaginado(idproyecto= session["idproyecto"], nroFase= nroFase, nombre=filtro, desde=desde, hasta=hasta)
            
    return render_template("modificarRelacionPorSC.html", lista = items,\
        item= item, nroFase=nroFase, filtro = filtro, primera=1, ultima= cantPaginas, ant= pagina-1,\
        sig=pagina +1, cantPaginas = cantPaginas, pagina = pagina)


def eliminarRelacionPorSC():
    """Metodo encargado de modificar un integrante del comite del proyecto"""
    if request.method == "GET":        
        iditem = request.args.getlist("iditem")[0]
        nroFase = request.args.getlist("nroFase")[0]
        filtro = request.args.getlist("filtro")[0]
        item = itemMgr.getItem(iditem)
        return render_template("eliminarRelacionPorSC.html", item= item)
#         return render_template("modificarRelacion.html", nroFase=nroFase, item= item, itemsRelacion= itemsRelacion, lista= lista)
    if request.method == "POST":
        iditem = request.form["iditem"]
        if request.form.getlist("check"):
#             iditemRelacion = request.form.getlist("check")[0]
            rel = request.form.getlist("check")[0].split("/")
            tipo = rel[0]
            iditemRelacion= rel[1]
            item = itemMgr.getItem(iditem)
            crearHistorial(item)
            if tipo == "izq":
                relacionMgr.eliminarRelacion(iditem, iditemRelacion)            
            else:
                relacionMgr.eliminarRelacion(iditemRelacion, iditem) 
            
            solicitud= item.solicitudes[0]
            votos = solicitud.votos
            for voto in votos:
                votosMgr.eliminarVoto(voto.idvoto)
            solicitudMgr.eliminarSolicitudCambio(solicitud.idsolicitud)
            ##Falta control de eliminacion
            item.usuarioHabilitado=None
            item.version = int(item.version) + 1
            item.fechaultimamod = datetime.date.today() 
            usuario=session["username"]
            usuarioUltimaMod = usuarioMgr.getUsuarioPorUser(usuario)
            item.usuarioUltimaMod= usuarioUltimaMod
            itemMgr.guardarItem(item)
            session["_flashes"]=[]
            flash("Relacion eliminada exitosamente");           
            return redirect(url_for('eliminarRelacionPorSC', iditem=item.iditem, filtro="", nroFase=item.fase.numero))

        return redirect(url_for("itemsEnSC", idfase=item.fase.idfase, filtro=""))

def cargarAtributosPorSC():
    if request.method == "GET":
        iditem=""
        if request.args.getlist("iditem"):
            iditem=request.args.getlist("iditem")[0]
        item = itemMgr.getItem(iditem)
        return render_template("cargarAtributosPorSC.html", item=item)
    
    if request.method == "POST":
        iditem=request.form["iditem"]
        item= itemMgr.getItem(iditem)
        crearHistorial(item)
        tipoItem =item.tipoItem
        if item.atributositem:
            for atributo in tipoItem.atributos:
                campo=request.form[atributo.campo]
                for atri in item.atributositem:
                    if atri.atributotipo.idatributotipo == atributo.idatributotipo:
                        atri.valor=campo;  
        else:
            for atributo in tipoItem.atributos:
                campo=request.form[atributo.campo]
                atributoItem= AtributoItem(valor=campo)
                atributoItem.atributotipo=atributo
                atributoItem.item=item
        
        solicitud= item.solicitudes[0]
        votos = solicitud.votos
        for voto in votos:
            votosMgr.eliminarVoto(voto.idvoto)
        solicitudMgr.eliminarSolicitudCambio(solicitud.idsolicitud)
        ##Falta control de eliminacion
        item.usuarioHabilitado=None
        
        item.fechaultimamod = datetime.date.today() 
        usuario=session["username"]
        usuarioUltimaMod = usuarioMgr.getUsuarioPorUser(usuario)
        item.usuarioUltimaMod= usuarioUltimaMod
        item.version = int(item.version) + 1
        itemMgr.guardarItem(item)
        session["_flashes"]=[]
        flash("Atributos cargados exitosamente") 
        return redirect(url_for("itemsEnSC", idfase=item.fase.idfase, filtro=""))


def paginarItemPorSC(idfase, pagina, filtro):
    """ Metodo encargado de la busqueda de item en solicitud a partir de un filtro """
    porPagina= 5
    pagina = int(pagina)
    usuario = usuarioMgr.getUsuarioFiltradoPorUser(session["username"])
    idusuario= usuario.idusuario
    total= itemMgr.getItemsEnSCPaginado(idfase, idusuario, filtro, None, None)
# 
    if total % porPagina == 0:
        cantPaginas= total/porPagina
    else:
        resto = total % porPagina
        subtotal = (total-resto)
        cantPaginas= (subtotal/porPagina) + 1
    hasta = pagina * porPagina
    desde = hasta - porPagina
    items= itemMgr.getItemsEnSCPaginado(idfase, idusuario, filtro, desde, hasta)

    return render_template("itemsEnSC.html", lista = items, idfase = idfase, \
        filtro = filtro, form=request.form, primera=1, ultima= cantPaginas, ant= pagina-1,\
        sig=pagina +1, cantPaginas = cantPaginas, pagina = pagina)
